Magnum One/Magnum One (Mid-American Digital) (Disc Manufacturing).iso/d18/turbotut.arc/MANUAL.EXE/lha/CHAP6.TXT

Text File | 1988-11-27 | 17KB | 388 lines

            CHAPTER 6 - Arrays, types, constants, and labels


                                  ARRAYS

            Having covered nearly all of the programming statements,
        we  must  now  go  back and fill in some gaps  in  our  data
        definition.

           One  of  the most useful data structures  is  the  ARRAY,
        which is,  in the simplest terms,  a group of many identical
        terms.   Lets go directly to an example to see what an array
        looks  like.   Edit the Pascal program ARRAYS and notice the
        third  line  starting  with  the  word  "automobiles".   The
        variable "automobiles" is defined as an integer variable but
        in addition,  it is defined to have twelve different integer
        variables,    namely    "automobile[1]",    "automobile[2]",
        "automobile[3]", .. "automobile[12]".  The square braces are
        used in Pascal to denote a subscript for an array  variable.
        The  array  definition  given  in line  3  is  the  standard
        definition for an array,  namely a variable name followed by
        a  colon and the reserved word ARRAY,  with the range of the
        array given in square brackets followed by another  reserved
        word OF and finally the type of variable.

            In using the elements of the array in a program, each of
        the elements of the array are required to be used in exactly
        the same manner as any simple variable having the same type.
        Each  time  one of the variables is used,  it must have  the
        subscript  since the subscript is now part of  the  variable
        name.   The subscript moreover,  must be of the type used in
        the definition and it must be within the range defined or it
        will be listed as an error.

            Now  consider the program itself.   As "index" is varied
        from 1 to 12, the range of the variable "automobile", the 12
        variables  are set to the series of values 11  to  22.   Any
        integer values could be used, this was only a convenient way
        to set the values to some numbers.   With the values stored,
        a  header  is  now printed and finally the  list  of  values
        contained in the array.   Note carefully that,  although the
        subscripts are limited to 1 through 12, the values stored in
        each  of  the 12 variables are limited only by the range  of
        integers,  namely -32768 to 32767.  Review this material and
        this program as long as needed to fully understand it, as it
        is very important.

                           DOUBLY INDEXED ARRAYS

            After understanding the above,  load the program ARRAYS2
        to see the next level of complexity of arrays.  You will see
        that "checkerboard" is defined as an array from 1 to 8,  but
        instead of it being a simple data type, it is itself another
        array from 1 to 8 of INTEGER.   The variable  "checkerboard"


                                Page 27









            CHAPTER 6 - Arrays, types, constants, and labels


        is  actually  composed  of 8 elements,  each of which  is  8
        elements,  leading to a total of 64 elements,  each of which
        is  a  simple INTEGER variable.   This is  called  a  doubly
        subscripted  array  and it can be envisioned in exactly  the
        same  manner  as a real checker board,  an 8  by  8  matrix.
        Another  way to achieve the same end is to define the double
        array  as in the next line of the program where  "value"  is
        defined as a total of 64 elements.

            To use either of the two variables in a program, we must
        add  two subscripts to the variable name to tell the program
        which  element of the 64 we desire to  use.   Examining  the
        program will reveal two loops,  one nested within the other,
        and both ranging in value from 1 to 8.  The two loop indices
        can  therefore  be used as subscripts of the  defined  array
        variables.   The  variable "checkerboard" is subscripted  by
        both  of  the loop indices and each of the 64  variables  is
        assigned a value as a function of the indices.  The assigned
        value  has  no real meaning other than to illustrate to  you
        how  it is done.   Since the value of "checkerboard" is  now
        available,  it is used to define some values to be used  for
        the variable "value".

            After  defining all of those variables,  and you  should
        understand  that we have defined a total of 128 variables in
        the double loop,  they can be printed out.  The next section
        of  the  program does just that,  by  using  another  doubly
        nested  loop,  with a WRITE statement in the  center.   Each
        time  we  go  through the center of the loop we tell  it  to
        print  out  one of the 64 variables  in  the  "checkerboard"
        matrix  with the indices "index" and "count" defining  which
        of  the variables to write each time.   Careful study of the
        loop should reveal its exact operation.

            After  printing out the matrix defined by  the  variable
        "checkerboard"  we  still  have the matrix  defined  by  the
        variable  "value"  intact  (In fact,  we still have  all  of
        "checkerboard"  available because we haven't changed any  of
        it).   Before  printing out the matrix defined  by  "value",
        let's  change  a few of the elements just to see how  it  is
        done.   The  next  three  lines simply change three  of  the
        variables  to illustrate that you can operate on all of  the
        matrix  in  loops,  or on any part of the matrix  in  simple
        assignment statements.  Notice especially the third line, in
        which  "value[3,6]" (which was just set to the value of  3),
        is used as a subscript.  This is perfectly legal since it is
        defined as a simple integer variable and is within the range
        of 1 to 8,  which is the requirement for a subscript of  the
        variable  "value".   The  last  part of the  program  simply
        prints  out  the 64 values of the variable "value"   in  the



                                Page 28









            CHAPTER 6 - Arrays, types, constants, and labels


        same manner as above.  Notice that when you run the program,
        the three values are in fact changed as expected.

                            ARRAYS ARE FLEXIBLE

            A  few  more words about arrays before we  go  on.   The
        arrays  in the last program were both defined to be  square,
        namely  8 by 8 but that choice was  purely  arbitrary.   The
        subscripts were chosen to go from 1 to 8 but they could have
        been  chosen to go from 101 to 108 or any other range needed
        to clearly define the problem at hand.  And, as you may have
        guessed,  you are not limited to a doubly subscripted matrix
        but you can define a variable with as many subscripts as you
        need  to  achieve your desired end.   There is  a  practical
        limit  to  the  number of subscripts because  you  can  very
        quickly  use up all of your available memory with one  large
        subscripted variable.

                            THE TYPE DEFINITION

            Now  that  you understand arrays,  lets look at  a  more
        convenient  way to define them by examining the Pascal  file
        TYPES.   You  will notice a new section at the beginning  of
        the listing with the heading TYPE.  TYPE is another reserved
        word  which  is used at the beginning of a section  used  to
        define  "user-defined  types".   Beginning with  the  simple
        predefined TYPES we studied earlier, we can build up as many
        new  types  as  we need and they can be  as  complex  as  we
        desire.   The  six names (from "array_def" to "boat") in the
        TYPE section are not variables,  but are defined to be TYPES
        and  can be used in the same manner as  can  INTEGER,  BYTE,
        REAL, etc.

            This  is a very difficult concept,  but a very important
        one.   The Pascal compiler is very picky about the  variable
        types  you  use in the program,  doing lots of  checking  to
        insure  that  you do not use the wrong type anywhere in  the
        program.   Because  it is picky,  you could do  very  little
        without  the  ability to define new types when  needed,  and
        that is the reason that you can define new types to solve  a
        particular problem.

            Some of these types are used in the VAR declaration part
        of the program.  Notice that since "airplane" is an array of
        "dog_food"  and  "dog_food" is in turn an array of  BOOLEAN,
        then  "airplane" defines a doubly  subscripted  array,  each
        element being a boolean variable.   This does not define any
        variables, only a TYPE, which can be used in a VAR to define
        a matrix of boolean variables.   This is in fact done in the
        definition of "puppies", which is an array composed of 72 (6
        times 12) boolean variables.  In the same manner, "stuff" is


                                Page 29









            CHAPTER 6 - Arrays, types, constants, and labels


        composed of an array of 14 variables,  each being an integer
        variable.   The  elements  of the  array  are,  "stuff[12]",
        "stuff[13]",  ..  "stuff[25]".  Notice also that "stuff2" is
        also defined in exactly the same manner and is also composed
        of 14 variables.

            Careful  inspection  will  reveal that  "kitties"  is  a
        variable  which  has the same definition as  "puppies".   It
        would  probably be poor programming practice to define  them
        in  different  manners  unless they  were  in  fact  totally
        disassociated.   In  this  example  program,  it  serves  to
        illustrate  some  of  the  ways user-defined  types  can  be
        defined.

            In  a tiny program like this example,  the value of  the
        TYPE declaration part cannot be appreciated,  but in a large
        program  with many variables,  the TYPE declaration  can  be
        used to great advantage.  This will be illustrated later.

                         THE CONSTANT DECLARATION

            Examining  the Pascal example program CONSTANT will give
        us an example of a constant definition.   The reserved  word
        CONST is the beginning of the section that is used to define
        constants  that can be used anyplace in the program as  long
        as  they  are  consistent  with  the  required  data  typing
        limitations.   In  this example,  "max_size" is defined as a
        constant  with the value of 12.  This is not a variable  and
        cannot  be  changed  in the program,  but is  still  a  very
        valuable  number.   For  the  moment  ignore  the  next  two
        constant definitions.   As we inspect the TYPE declarations,
        we see two user-defined types,  both of which are arrays  of
        size  1 to 12 since "max_size" is defined as 12.   Then when
        we get to the VAR declaration part,  we find five  different
        variables,  all  defined  as arrays from 1 to 12  (some  are
        INTEGER and some are CHAR).   When we come to the program we
        find  that  it is one big loop which we go through 12  times
        because the loop is executed "max_size" times.

            In the above definition,  there seems to be no advantage
        to  using the constant,  and there is none,  until you  find
        that  for some reason you wish to increase the range of  all
        arrays from 12 to 18.   In order to do so,  you only need to
        redefine the value of the constant, recompile, and the whole
        job  is done.   Without the constant definition,  you  would
        have had to change all TYPE declarations and the upper limit
        of the loop in the program.  Of course that would not be too
        bad in the small example program,  but could be a real  mess
        in  a 2000 line program,  especially if you missed  changing
        one  of the 12's to an 18.   That would be a good example of
        data in and garbage out.   That should give you a good  idea


                                Page 30









            CHAPTER 6 - Arrays, types, constants, and labels


        of  what  the constant can be used for,  and as you  develop
        good  programming  techniques,  you will  use  the  constant
        declaration to your advantage.

                      THE TURBO PASCAL TYPED CONSTANT

            We   skipped   over  the  second  and   third   constant
        declaration  for a very good reason,  they are not  constant
        declarations.   TURBO  Pascal has defined,  as an extension,
        the "typed constant".  Using the syntax shown, "index_start"
        is defined as an INTEGER variable and is initialized to  the
        value  of  49.   This is a true variable and can be used  as
        such  in the program.   The same effect can be  achieved  by
        simply  defining  "index_start"  as an INTEGER  in  the  VAR
        declaration  part  and setting it to the value of 49 in  the
        program itself.  Since it does not really fit the definition
        of  a  constant,  it's  use is discouraged  until  you  gain
        experience  as  a Pascal programmer.   Until  then  it  will
        probably  only  be  confusing  to  you.    In  like  manner,
        "check_it_out"  is  a  boolean variable initialized  to  the
        value "true".  It is not a constant.

                           THE LABEL DECLARATION

            Finally,  the example program LABELS will illustrate the
        use  of  labels.   In the Pascal definition,  a LABEL  is  a
        number from 0 to 9999 that is used to define a point in  the
        program  to  which  you wish to jump.   All labels  must  be
        defined  in the LABEL definition part of the program  before
        they can be used.   Then a new reserved word GOTO is used to
        jump to that point in the program.   The best way to see how
        the  GOTO  is  used with labels is to  examine  the  program
        before you.   TURBO Pascal has an extension for labels.  Any
        valid identifier, such as used for variables, can be used as
        a label in addition to the values from 0 to 9999.  These are
        illustrated in the example program.

                             THE PACKED ARRAY

            When  Pascal  was first defined in  1971,  many  of  the
        computers in use at that time used very large words, 60 bits
        being  a typical word size.   Memory was very expensive,  so
        large memories were not too common.   A Pascal program  that
        used  arrays  was inefficient because only one variable  was
        stored  in each word.   Most of the bits in each  word  were
        totally  wasted,  so  the PACKED ARRAY was defined in  which
        several  variables  were stored in each  word.   This  saved
        storage space but took extra time to unpack each word to use
        the data.  The programmer was given a choice of using a fast
        scheme  that wasted memory,  the ARRAY,  or a slower  scheme
        that used memory more efficiently, the PACKED ARRAY.


                                Page 31









            CHAPTER 6 - Arrays, types, constants, and labels



            The modern microcomputer has the best of both schemes, a
        short word, usually 16 bits, and a large memory.  The PACKED
        ARRAY  is therefore not even implemented in  many  compilers
        and will be ignored during compilation.


                           PROGRAMMING EXERCISES

        1.  Write  a program to store the integers 201 to 212 in  an
            array then display them on the monitor.

        2.  Write a program to store a 10 by 10 array containing the
            products  of  the indices,  therefore  a  multiplication
            table. Display the matrix on the video monitor.

        3.  Modify  the program in 2 above to include a constant  so
            that  by simply changing the constant,  the size of  the
            matrix and the range of the table will be changed.


































                                Page 32